// **********************************************************************
//
// Copyright (c) 2003-2008 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

// Ice version 3.3.0
// Generated from file `Interface.ice'

#ifndef __Interface_h__
#define __Interface_h__

#include <Ice/LocalObjectF.h>
#include <Ice/ProxyF.h>
#include <Ice/ObjectF.h>
#include <Ice/Exception.h>
#include <Ice/LocalObject.h>
#include <Ice/Proxy.h>
#include <Ice/Object.h>
#include <Ice/Outgoing.h>
#include <Ice/OutgoingAsync.h>
#include <Ice/Incoming.h>
#include <Ice/IncomingAsync.h>
#include <Ice/Direct.h>
#include <Ice/UserExceptionFactory.h>
#include <Ice/FactoryTable.h>
#include <Ice/StreamF.h>
#include <Ice/UndefSysMacros.h>

#ifndef ICE_IGNORE_VERSION
#   if ICE_INT_VERSION / 100 != 303
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 > 50
#       error Beta header file detected
#   endif
#   if ICE_INT_VERSION % 100 < 0
#       error Ice patch level mismatch!
#   endif
#endif

namespace IceProxy
{

	namespace PPIce
	{

		class SinglConSql;

		class C;

		class NewBankProxy;

	}

}

namespace PPIce
{

	class SinglConSql;
	bool operator==(const SinglConSql&, const SinglConSql&);
	bool operator<(const SinglConSql&, const SinglConSql&);

	class C;
	bool operator==(const C&, const C&);
	bool operator<(const C&, const C&);

	class NewBankProxy;
	bool operator==(const NewBankProxy&, const NewBankProxy&);
	bool operator<(const NewBankProxy&, const NewBankProxy&);

}

namespace IceInternal
{

	::Ice::Object* upCast(::PPIce::SinglConSql*);
	::IceProxy::Ice::Object* upCast(::IceProxy::PPIce::SinglConSql*);

	::Ice::Object* upCast(::PPIce::C*);
	::IceProxy::Ice::Object* upCast(::IceProxy::PPIce::C*);

	::Ice::Object* upCast(::PPIce::NewBankProxy*);
	::IceProxy::Ice::Object* upCast(::IceProxy::PPIce::NewBankProxy*);

}

namespace PPIce
{

	typedef ::IceInternal::Handle< ::PPIce::SinglConSql> SinglConSqlPtr;
	typedef ::IceInternal::ProxyHandle< ::IceProxy::PPIce::SinglConSql> SinglConSqlPrx;

	void __read(::IceInternal::BasicStream*, SinglConSqlPrx&);
	void __patch__SinglConSqlPtr(void*, ::Ice::ObjectPtr&);

	typedef ::IceInternal::Handle< ::PPIce::C> CPtr;
	typedef ::IceInternal::ProxyHandle< ::IceProxy::PPIce::C> CPrx;

	void __read(::IceInternal::BasicStream*, CPrx&);
	void __patch__CPtr(void*, ::Ice::ObjectPtr&);

	typedef ::IceInternal::Handle< ::PPIce::NewBankProxy> NewBankProxyPtr;
	typedef ::IceInternal::ProxyHandle< ::IceProxy::PPIce::NewBankProxy> NewBankProxyPrx;

	void __read(::IceInternal::BasicStream*, NewBankProxyPrx&);
	void __patch__NewBankProxyPtr(void*, ::Ice::ObjectPtr&);

}

namespace PPIce
{

	class RequestCanceledException : public ::Ice::UserException
	{
		public:

			RequestCanceledException() {}
			virtual ~RequestCanceledException() throw();

			virtual ::std::string ice_name() const;
			virtual ::Ice::Exception* ice_clone() const;
			virtual void ice_throw() const;

			static const ::IceInternal::UserExceptionFactoryPtr& ice_factory();

			virtual void __write(::IceInternal::BasicStream*) const;
			virtual void __read(::IceInternal::BasicStream*, bool);
			virtual void __write(const ::Ice::OutputStreamPtr&) const;
			virtual void __read(const ::Ice::InputStreamPtr&, bool);
	};

	static RequestCanceledException __RequestCanceledException_init;

	typedef ::std::map< ::std::string, ::std::string> StringDict;
	void __writeStringDict(::IceInternal::BasicStream*, const StringDict&);
	void __readStringDict(::IceInternal::BasicStream*, StringDict&);

	typedef ::std::vector< ::PPIce::StringDict> SequenceStringDict;
	void __writeSequenceStringDict(::IceInternal::BasicStream*, const ::PPIce::StringDict*, const ::PPIce::StringDict*);
	void __readSequenceStringDict(::IceInternal::BasicStream*, SequenceStringDict&);

	typedef ::std::vector< ::std::string> StringSeq;

	typedef ::std::map< ::std::string, ::std::string> ResultA;
	void __writeResultA(::IceInternal::BasicStream*, const ResultA&);
	void __readResultA(::IceInternal::BasicStream*, ResultA&);

	typedef ::std::map< ::Ice::Int, ::PPIce::ResultA> ResultB;
	void __writeResultB(::IceInternal::BasicStream*, const ResultB&);
	void __readResultB(::IceInternal::BasicStream*, ResultB&);

	typedef ::std::map< ::std::string, ::PPIce::ResultB> ResultC;
	void __writeResultC(::IceInternal::BasicStream*, const ResultC&);
	void __readResultC(::IceInternal::BasicStream*, ResultC&);

	typedef ::std::vector< ::PPIce::ResultB> SequenceResultB;
	void __writeSequenceResultB(::IceInternal::BasicStream*, const ::PPIce::ResultB*, const ::PPIce::ResultB*);
	void __readSequenceResultB(::IceInternal::BasicStream*, SequenceResultB&);

	struct Structure
	{
		::std::string name;
		::PPIce::StringDict value;

		bool operator==(const Structure&) const;
		bool operator<(const Structure&) const;
		bool operator!=(const Structure& __rhs) const
		{
			return !operator==(__rhs);
		}
		bool operator<=(const Structure& __rhs) const
		{
			return operator<(__rhs) || operator==(__rhs);
		}
		bool operator>(const Structure& __rhs) const
		{
			return !operator<(__rhs) && !operator==(__rhs);
		}
		bool operator>=(const Structure& __rhs) const
		{
			return !operator<(__rhs);
		}

		void __write(::IceInternal::BasicStream*) const;
		void __read(::IceInternal::BasicStream*);
	};

	typedef ::std::vector< ::PPIce::Structure> StructureSeq;
	void __writeStructureSeq(::IceInternal::BasicStream*, const ::PPIce::Structure*, const ::PPIce::Structure*);
	void __readStructureSeq(::IceInternal::BasicStream*, StructureSeq&);

}

namespace PPIce
{

	class AMI_SinglConSql_ExecSql : public ::IceInternal::OutgoingAsync
	{
		public:

			virtual void ice_response() = 0;
			virtual void ice_exception(const ::Ice::Exception&) = 0;

			bool __invoke(const ::PPIce::SinglConSqlPrx&, const ::std::string&, const ::std::string&, const ::std::string&, const ::Ice::Context*);

		protected:

			virtual void __response(bool);
	};

	typedef ::IceUtil::Handle< ::PPIce::AMI_SinglConSql_ExecSql> AMI_SinglConSql_ExecSqlPtr;

	class AMD_SinglConSql_ExecSql : virtual public ::IceUtil::Shared
	{
		public:

			virtual void ice_response() = 0;
			virtual void ice_exception(const ::std::exception&) = 0;
			virtual void ice_exception() = 0;
	};

	typedef ::IceUtil::Handle< ::PPIce::AMD_SinglConSql_ExecSql> AMD_SinglConSql_ExecSqlPtr;

}

namespace IceAsync
{

	namespace PPIce
	{

		class AMD_SinglConSql_ExecSql : public ::PPIce::AMD_SinglConSql_ExecSql, public ::IceInternal::IncomingAsync
		{
			public:

				AMD_SinglConSql_ExecSql(::IceInternal::Incoming&);

				virtual void ice_response();
				virtual void ice_exception(const ::std::exception&);
				virtual void ice_exception();
		};

	}

}

namespace IceProxy
{

	namespace PPIce
	{

		class SinglConSql : virtual public ::IceProxy::Ice::Object
		{
			public:

				void ExecSql(const ::std::string& ClientSql, const ::std::string& Ip, const ::std::string& DbName)
				{
					ExecSql(ClientSql, Ip, DbName, 0);
				}
				void ExecSql(const ::std::string& ClientSql, const ::std::string& Ip, const ::std::string& DbName, const ::Ice::Context& __ctx)
				{
					ExecSql(ClientSql, Ip, DbName, &__ctx);
				}

			private:

				void ExecSql(const ::std::string&, const ::std::string&, const ::std::string&, const ::Ice::Context*);

			public:
				bool ExecSql_async(const ::PPIce::AMI_SinglConSql_ExecSqlPtr&, const ::std::string&, const ::std::string&, const ::std::string&);
				bool ExecSql_async(const ::PPIce::AMI_SinglConSql_ExecSqlPtr&, const ::std::string&, const ::std::string&, const ::std::string&, const ::Ice::Context&);

				::IceInternal::ProxyHandle<SinglConSql> ice_context(const ::Ice::Context& __context) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_context(__context).get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_context(__context).get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_adapterId(const std::string& __id) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_adapterId(__id).get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_endpoints(__endpoints).get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_locatorCacheTimeout(int __timeout) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_locatorCacheTimeout(__timeout).get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_connectionCached(bool __cached) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_connectionCached(__cached).get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_endpointSelection(__est).get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_secure(bool __secure) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_secure(__secure).get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_preferSecure(bool __preferSecure) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_preferSecure(__preferSecure).get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_router(const ::Ice::RouterPrx& __router) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_router(__router).get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_router(__router).get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_locator(const ::Ice::LocatorPrx& __locator) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_locator(__locator).get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_collocationOptimized(bool __co) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_collocationOptimized(__co).get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_twoway() const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_twoway().get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_twoway().get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_oneway() const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_oneway().get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_oneway().get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_batchOneway() const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_batchOneway().get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_batchOneway().get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_datagram() const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_datagram().get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_datagram().get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_batchDatagram() const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_batchDatagram().get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_compress(bool __compress) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_compress(__compress).get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_timeout(int __timeout) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_timeout(__timeout).get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
#endif
				}

				::IceInternal::ProxyHandle<SinglConSql> ice_connectionId(const std::string& __id) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<SinglConSql*>(_Base::ice_connectionId(__id).get());
#else
					return dynamic_cast<SinglConSql*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
#endif
				}

				static const ::std::string& ice_staticId();

			private: 

				virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
				virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
				virtual ::IceProxy::Ice::Object* __newInstance() const;
		};

		class C : virtual public ::IceProxy::Ice::Object
		{
			public:

				::IceInternal::ProxyHandle<C> ice_context(const ::Ice::Context& __context) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_context(__context).get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_context(__context).get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_adapterId(const std::string& __id) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_adapterId(__id).get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_endpoints(__endpoints).get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_locatorCacheTimeout(int __timeout) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_locatorCacheTimeout(__timeout).get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_connectionCached(bool __cached) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_connectionCached(__cached).get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_endpointSelection(__est).get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_secure(bool __secure) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_secure(__secure).get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_preferSecure(bool __preferSecure) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_preferSecure(__preferSecure).get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_router(const ::Ice::RouterPrx& __router) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_router(__router).get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_router(__router).get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_locator(const ::Ice::LocatorPrx& __locator) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_locator(__locator).get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_collocationOptimized(bool __co) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_collocationOptimized(__co).get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_twoway() const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_twoway().get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_twoway().get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_oneway() const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_oneway().get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_oneway().get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_batchOneway() const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_batchOneway().get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_batchOneway().get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_datagram() const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_datagram().get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_datagram().get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_batchDatagram() const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_batchDatagram().get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_compress(bool __compress) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_compress(__compress).get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_timeout(int __timeout) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_timeout(__timeout).get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
#endif
				}

				::IceInternal::ProxyHandle<C> ice_connectionId(const std::string& __id) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<C*>(_Base::ice_connectionId(__id).get());
#else
					return dynamic_cast<C*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
#endif
				}

				static const ::std::string& ice_staticId();

			private: 

				virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
				virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
				virtual ::IceProxy::Ice::Object* __newInstance() const;
		};

		class NewBankProxy : virtual public ::IceProxy::Ice::Object
		{
			public:

				::PPIce::ResultA NewBankAccountInfoServer(const ::std::string& userid)
				{
					return NewBankAccountInfoServer(userid, 0);
				}
				::PPIce::ResultA NewBankAccountInfoServer(const ::std::string& userid, const ::Ice::Context& __ctx)
				{
					return NewBankAccountInfoServer(userid, &__ctx);
				}

			private:

				::PPIce::ResultA NewBankAccountInfoServer(const ::std::string&, const ::Ice::Context*);

			public:

				::PPIce::ResultA NewBankCongealThawServer(const ::std::string& userid, ::Ice::Short action)
				{
					return NewBankCongealThawServer(userid, action, 0);
				}
				::PPIce::ResultA NewBankCongealThawServer(const ::std::string& userid, ::Ice::Short action, const ::Ice::Context& __ctx)
				{
					return NewBankCongealThawServer(userid, action, &__ctx);
				}

			private:

				::PPIce::ResultA NewBankCongealThawServer(const ::std::string&, ::Ice::Short, const ::Ice::Context*);

			public:

				::PPIce::ResultA NewBankUserMoneyquantumGet(const ::std::string& userid)
				{
					return NewBankUserMoneyquantumGet(userid, 0);
				}
				::PPIce::ResultA NewBankUserMoneyquantumGet(const ::std::string& userid, const ::Ice::Context& __ctx)
				{
					return NewBankUserMoneyquantumGet(userid, &__ctx);
				}

			private:

				::PPIce::ResultA NewBankUserMoneyquantumGet(const ::std::string&, const ::Ice::Context*);

			public:

				void NewBankAddGoldTest(const ::std::string& userid, ::Ice::Int gold, const ::std::string& frombanknum, const ::std::string& objid)
				{
					NewBankAddGoldTest(userid, gold, frombanknum, objid, 0);
				}
				void NewBankAddGoldTest(const ::std::string& userid, ::Ice::Int gold, const ::std::string& frombanknum, const ::std::string& objid, const ::Ice::Context& __ctx)
				{
					NewBankAddGoldTest(userid, gold, frombanknum, objid, &__ctx);
				}

			private:

				void NewBankAddGoldTest(const ::std::string&, ::Ice::Int, const ::std::string&, const ::std::string&, const ::Ice::Context*);

			public:

				::PPIce::ResultC NewBankServerActionB(const ::PPIce::ResultB& InputArray, const ::std::string& frombanknum)
				{
					return NewBankServerActionB(InputArray, frombanknum, 0);
				}
				::PPIce::ResultC NewBankServerActionB(const ::PPIce::ResultB& InputArray, const ::std::string& frombanknum, const ::Ice::Context& __ctx)
				{
					return NewBankServerActionB(InputArray, frombanknum, &__ctx);
				}

			private:

				::PPIce::ResultC NewBankServerActionB(const ::PPIce::ResultB&, const ::std::string&, const ::Ice::Context*);

			public:

				::PPIce::ResultC NewBankServerActionSequenceB(const ::PPIce::SequenceResultB& SequenceInputArray, const ::std::string& frombanknum)
				{
					return NewBankServerActionSequenceB(SequenceInputArray, frombanknum, 0);
				}
				::PPIce::ResultC NewBankServerActionSequenceB(const ::PPIce::SequenceResultB& SequenceInputArray, const ::std::string& frombanknum, const ::Ice::Context& __ctx)
				{
					return NewBankServerActionSequenceB(SequenceInputArray, frombanknum, &__ctx);
				}

			private:

				::PPIce::ResultC NewBankServerActionSequenceB(const ::PPIce::SequenceResultB&, const ::std::string&, const ::Ice::Context*);

			public:

				::IceInternal::ProxyHandle<NewBankProxy> ice_context(const ::Ice::Context& __context) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_context(__context).get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_context(__context).get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_adapterId(const std::string& __id) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_adapterId(__id).get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_endpoints(__endpoints).get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_locatorCacheTimeout(int __timeout) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_locatorCacheTimeout(__timeout).get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_connectionCached(bool __cached) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_connectionCached(__cached).get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_endpointSelection(__est).get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_secure(bool __secure) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_secure(__secure).get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_preferSecure(bool __preferSecure) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_preferSecure(__preferSecure).get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_router(const ::Ice::RouterPrx& __router) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_router(__router).get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_router(__router).get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_locator(const ::Ice::LocatorPrx& __locator) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_locator(__locator).get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_collocationOptimized(bool __co) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_collocationOptimized(__co).get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_twoway() const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_twoway().get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_twoway().get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_oneway() const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_oneway().get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_oneway().get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_batchOneway() const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_batchOneway().get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_batchOneway().get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_datagram() const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_datagram().get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_datagram().get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_batchDatagram() const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_batchDatagram().get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_compress(bool __compress) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_compress(__compress).get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_timeout(int __timeout) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_timeout(__timeout).get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
#endif
				}

				::IceInternal::ProxyHandle<NewBankProxy> ice_connectionId(const std::string& __id) const
				{
#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
					typedef ::IceProxy::Ice::Object _Base;
					return dynamic_cast<NewBankProxy*>(_Base::ice_connectionId(__id).get());
#else
					return dynamic_cast<NewBankProxy*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
#endif
				}

				static const ::std::string& ice_staticId();

			private: 

				virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
				virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
				virtual ::IceProxy::Ice::Object* __newInstance() const;
		};

	}

}

namespace IceDelegate
{

	namespace PPIce
	{

		class SinglConSql : virtual public ::IceDelegate::Ice::Object
		{
			public:

				virtual void ExecSql(const ::std::string&, const ::std::string&, const ::std::string&, const ::Ice::Context*) = 0;
		};

		class C : virtual public ::IceDelegate::Ice::Object
		{
			public:
		};

		class NewBankProxy : virtual public ::IceDelegate::Ice::Object
		{
			public:

				virtual ::PPIce::ResultA NewBankAccountInfoServer(const ::std::string&, const ::Ice::Context*) = 0;

				virtual ::PPIce::ResultA NewBankCongealThawServer(const ::std::string&, ::Ice::Short, const ::Ice::Context*) = 0;

				virtual ::PPIce::ResultA NewBankUserMoneyquantumGet(const ::std::string&, const ::Ice::Context*) = 0;

				virtual void NewBankAddGoldTest(const ::std::string&, ::Ice::Int, const ::std::string&, const ::std::string&, const ::Ice::Context*) = 0;

				virtual ::PPIce::ResultC NewBankServerActionB(const ::PPIce::ResultB&, const ::std::string&, const ::Ice::Context*) = 0;

				virtual ::PPIce::ResultC NewBankServerActionSequenceB(const ::PPIce::SequenceResultB&, const ::std::string&, const ::Ice::Context*) = 0;
		};

	}

}

namespace IceDelegateM
{

	namespace PPIce
	{

		class SinglConSql : virtual public ::IceDelegate::PPIce::SinglConSql,
		virtual public ::IceDelegateM::Ice::Object
		{
			public:

				virtual void ExecSql(const ::std::string&, const ::std::string&, const ::std::string&, const ::Ice::Context*);
		};

		class C : virtual public ::IceDelegate::PPIce::C,
		virtual public ::IceDelegateM::Ice::Object
		{
			public:
		};

		class NewBankProxy : virtual public ::IceDelegate::PPIce::NewBankProxy,
		virtual public ::IceDelegateM::Ice::Object
		{
			public:

				virtual ::PPIce::ResultA NewBankAccountInfoServer(const ::std::string&, const ::Ice::Context*);

				virtual ::PPIce::ResultA NewBankCongealThawServer(const ::std::string&, ::Ice::Short, const ::Ice::Context*);

				virtual ::PPIce::ResultA NewBankUserMoneyquantumGet(const ::std::string&, const ::Ice::Context*);

				virtual void NewBankAddGoldTest(const ::std::string&, ::Ice::Int, const ::std::string&, const ::std::string&, const ::Ice::Context*);

				virtual ::PPIce::ResultC NewBankServerActionB(const ::PPIce::ResultB&, const ::std::string&, const ::Ice::Context*);

				virtual ::PPIce::ResultC NewBankServerActionSequenceB(const ::PPIce::SequenceResultB&, const ::std::string&, const ::Ice::Context*);
		};

	}

}

namespace IceDelegateD
{

	namespace PPIce
	{

		class SinglConSql : virtual public ::IceDelegate::PPIce::SinglConSql,
		virtual public ::IceDelegateD::Ice::Object
		{
			public:

				virtual void ExecSql(const ::std::string&, const ::std::string&, const ::std::string&, const ::Ice::Context*);
		};

		class C : virtual public ::IceDelegate::PPIce::C,
		virtual public ::IceDelegateD::Ice::Object
		{
			public:
		};

		class NewBankProxy : virtual public ::IceDelegate::PPIce::NewBankProxy,
		virtual public ::IceDelegateD::Ice::Object
		{
			public:

				virtual ::PPIce::ResultA NewBankAccountInfoServer(const ::std::string&, const ::Ice::Context*);

				virtual ::PPIce::ResultA NewBankCongealThawServer(const ::std::string&, ::Ice::Short, const ::Ice::Context*);

				virtual ::PPIce::ResultA NewBankUserMoneyquantumGet(const ::std::string&, const ::Ice::Context*);

				virtual void NewBankAddGoldTest(const ::std::string&, ::Ice::Int, const ::std::string&, const ::std::string&, const ::Ice::Context*);

				virtual ::PPIce::ResultC NewBankServerActionB(const ::PPIce::ResultB&, const ::std::string&, const ::Ice::Context*);

				virtual ::PPIce::ResultC NewBankServerActionSequenceB(const ::PPIce::SequenceResultB&, const ::std::string&, const ::Ice::Context*);
		};

	}

}

namespace PPIce
{

	class SinglConSql : virtual public ::Ice::Object
	{
		public:

			typedef SinglConSqlPrx ProxyType;
			typedef SinglConSqlPtr PointerType;

			virtual ::Ice::ObjectPtr ice_clone() const;

			virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
			virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
			virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
			static const ::std::string& ice_staticId();

			virtual void ExecSql_async(const ::PPIce::AMD_SinglConSql_ExecSqlPtr&, const ::std::string&, const ::std::string&, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
			::Ice::DispatchStatus ___ExecSql(::IceInternal::Incoming&, const ::Ice::Current&);

			virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);

			virtual void __write(::IceInternal::BasicStream*) const;
			virtual void __read(::IceInternal::BasicStream*, bool);
			virtual void __write(const ::Ice::OutputStreamPtr&) const;
			virtual void __read(const ::Ice::InputStreamPtr&, bool);
	};

	class C : virtual public ::Ice::Object
	{
		public:

			typedef CPrx ProxyType;
			typedef CPtr PointerType;

			C() {}
			explicit C(const ::PPIce::Structure&);
			virtual ::Ice::ObjectPtr ice_clone() const;

			virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
			virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
			virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
			static const ::std::string& ice_staticId();


			virtual void __write(::IceInternal::BasicStream*) const;
			virtual void __read(::IceInternal::BasicStream*, bool);
			virtual void __write(const ::Ice::OutputStreamPtr&) const;
			virtual void __read(const ::Ice::InputStreamPtr&, bool);

			static const ::Ice::ObjectFactoryPtr& ice_factory();

		protected:

			virtual ~C() {}

			friend class C__staticInit;

		public:

			::PPIce::Structure s;
	};

	class C__staticInit
	{
		public:

			::PPIce::C _init;
	};

	static ::PPIce::C__staticInit _C_init;

	class NewBankProxy : virtual public ::Ice::Object
	{
		public:

			typedef NewBankProxyPrx ProxyType;
			typedef NewBankProxyPtr PointerType;

			virtual ::Ice::ObjectPtr ice_clone() const;

			virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
			virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
			virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
			static const ::std::string& ice_staticId();

			virtual ::PPIce::ResultA NewBankAccountInfoServer(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
			::Ice::DispatchStatus ___NewBankAccountInfoServer(::IceInternal::Incoming&, const ::Ice::Current&);

			virtual ::PPIce::ResultA NewBankCongealThawServer(const ::std::string&, ::Ice::Short, const ::Ice::Current& = ::Ice::Current()) = 0;
			::Ice::DispatchStatus ___NewBankCongealThawServer(::IceInternal::Incoming&, const ::Ice::Current&);

			virtual ::PPIce::ResultA NewBankUserMoneyquantumGet(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
			::Ice::DispatchStatus ___NewBankUserMoneyquantumGet(::IceInternal::Incoming&, const ::Ice::Current&);

			virtual void NewBankAddGoldTest(const ::std::string&, ::Ice::Int, const ::std::string&, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
			::Ice::DispatchStatus ___NewBankAddGoldTest(::IceInternal::Incoming&, const ::Ice::Current&);

			virtual ::PPIce::ResultC NewBankServerActionB(const ::PPIce::ResultB&, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
			::Ice::DispatchStatus ___NewBankServerActionB(::IceInternal::Incoming&, const ::Ice::Current&);

			virtual ::PPIce::ResultC NewBankServerActionSequenceB(const ::PPIce::SequenceResultB&, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
			::Ice::DispatchStatus ___NewBankServerActionSequenceB(::IceInternal::Incoming&, const ::Ice::Current&);

			virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);

			virtual void __write(::IceInternal::BasicStream*) const;
			virtual void __read(::IceInternal::BasicStream*, bool);
			virtual void __write(const ::Ice::OutputStreamPtr&) const;
			virtual void __read(const ::Ice::InputStreamPtr&, bool);
	};

}

#endif
